home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / gdb.new / gdb-3.98 / gdb / mtrace.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-01  |  4.1 KB  |  147 lines
  1. /* More debugging hooks for `malloc'.
  2.    Copyright 1991 Free Software Foundation
  3.           Written April 2, 1991 by John Gilmore of Cygnus Support
  4.           Based on mcheck.c by Mike Haertel.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include <stdio.h>
  21. #include "ansidecl.h"
  22.  
  23. /* size_t may be defined in the system-supplied stdio.h.  */
  24. /* So just kludge it.  */
  25. #define size_t unsigned int
  26. #define ptrdiff_t int
  27. #define __ONEFILE
  28.  
  29. /* We can't declare malloc and realloc here because we don't know
  30.    if they are char * or void *, and the compiler will give an error
  31.    if we get it wrong and they happen to be defined in some header
  32.    file e.g. <stdio.h>.  We can't include <stdlib.h> here because
  33.    it has some incompatability with our own includes, e.g. size_t or 
  34.    whatever.  So we just punt.  This causes malloc and realloc to
  35.    default to returning "int", which works for most cases we care
  36.    about.  FIXME-somehow.  */
  37. /* #include <stdlib.h> */
  38. #include "gmalloc.h"
  39.  
  40. extern char *getenv();
  41.  
  42. FILE *mallstream;
  43. char mallenv[] = "MALLOC_TRACE";
  44. static char mallbuf[BUFSIZ];        /* Buffer for the output */
  45.  
  46. /* Address to breakpoint on accesses to... */
  47. PTR mallwatch;
  48.  
  49. /* Old hook values.  */
  50. static void EXFUN((*old_free_hook), (PTR ptr));
  51. static PTR EXFUN((*old_malloc_hook), (size_t size));
  52. static PTR EXFUN((*old_realloc_hook), (PTR ptr, size_t size));
  53.  
  54. /* This function is called when the block being alloc'd, realloc'd, or
  55.    freed has an address matching the variable "mallwatch".  In a debugger,
  56.    set "mallwatch" to the address of interest, then put a breakpoint on
  57.    tr_break.  */
  58.  
  59. void
  60. tr_break()
  61. {
  62.   ;
  63. }
  64.  
  65. static void
  66. DEFUN(tr_freehook, (ptr), PTR ptr)
  67. {
  68.   fprintf(mallstream, "- %08x\n", ptr);    /* Be sure to print it first */
  69.   if (ptr == mallwatch)
  70.     tr_break();
  71.   __free_hook = old_free_hook;
  72.   free(ptr);
  73.   __free_hook = tr_freehook;
  74. }
  75.  
  76. static PTR
  77. DEFUN(tr_mallochook, (size), size_t size)
  78. {
  79.   PTR hdr;
  80.  
  81.   __malloc_hook = old_malloc_hook;
  82.   hdr = (PTR) malloc(size);
  83.   __malloc_hook = tr_mallochook;
  84.  
  85.   /* We could be printing a NULL here; that's OK */
  86.   fprintf (mallstream, "+ %08x %x\n", hdr, size);
  87.  
  88.   if (hdr == mallwatch)
  89.     tr_break();
  90.  
  91.   return hdr;
  92. }
  93.  
  94. static PTR
  95. DEFUN(tr_reallochook, (ptr, size), PTR ptr AND size_t size)
  96. {
  97.   PTR hdr;
  98.  
  99.   if (ptr == mallwatch)
  100.     tr_break();
  101.  
  102.   __free_hook = old_free_hook;
  103.   __malloc_hook = old_malloc_hook;
  104.   __realloc_hook = old_realloc_hook;
  105.   hdr = (PTR) realloc(ptr, size);
  106.   __free_hook = tr_freehook;
  107.   __malloc_hook = tr_mallochook;
  108.   __realloc_hook = tr_reallochook;
  109.   if (hdr == NULL) {
  110.     fprintf (mallstream, "! %08x %x\n", ptr, size);    /* Failed realloc */
  111.   } else {
  112.     fprintf (mallstream, "< %08x\n> %08x %x\n", ptr, hdr, size);
  113.   }
  114.  
  115.   if (hdr == mallwatch)
  116.     tr_break();
  117.  
  118.   return hdr;
  119. }
  120.  
  121. /* We enable tracing if either the environment variable MALLOC_TRACE
  122.    is set, or if the variable mallwatch has been patched to an address
  123.    that the debugging user wants us to stop on.  When patching mallwatch,
  124.    don't forget to set a breakpoint on tr_break!  */
  125.  
  126. void
  127. mtrace()
  128. {
  129.   char *mallfile;
  130.  
  131.   mallfile = getenv (mallenv);
  132.   if (mallfile || mallwatch) {
  133.     mallstream = fopen (mallfile? mallfile: "/dev/null", "w");
  134.     if (mallstream) {
  135.       /* Be sure it doesn't malloc its buffer! */
  136.       setbuf (mallstream, mallbuf);
  137.       fprintf (mallstream, "= Start\n");
  138.       old_free_hook = __free_hook;
  139.       __free_hook = tr_freehook;
  140.       old_malloc_hook = __malloc_hook;
  141.       __malloc_hook = tr_mallochook;
  142.       old_realloc_hook = __realloc_hook;
  143.       __realloc_hook = tr_reallochook;
  144.     }
  145.   }
  146. }
  147.